home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 22 / AACD 22.iso / AACD / Sound / Subspace68k / src / Waveshapes.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-05-04  |  10.5 KB  |  452 lines
  1.  
  2. #include <exec/types.h>
  3. #include <math.h>
  4.  
  5. #include <libraries/amplifierplugin.h>
  6. #include <clib/amplifierplugin_protos.h>
  7. #include <pragma/amplifierplugin_lib.h>
  8.  
  9. extern int amplifier;
  10. extern struct Library *AMPlifierPluginBase;
  11.  
  12. #ifdef __SASC
  13.     #define M_PI PI
  14. #endif
  15. #ifdef __VBCC__
  16. #define   M_PI 3.14159265358979323846
  17. #endif
  18.  
  19. float rnd(float max);
  20.  
  21. float wa0[2], wa1[2], wa2[2], wa3[2], wa4[2], wa5[2], wa6[2], wa7[2], wa8[2];
  22. float wb0[2], wb1[2], wb2[2], wb3[2], wb4[2], wb5[2], wb6[2], wb7[2], wb8[2];
  23.  
  24. extern ULONG TimeWave;
  25. extern WORD     *PluginSamples;
  26.  
  27. void InitWave(UBYTE WaveNum, ULONG BufNum) {
  28.     float a0,a1,a2,a3,a4;
  29.     a0=a1=a2=a3=a4=0.0;
  30.     switch(WaveNum) {
  31.         /****************************************/
  32.         case 0:
  33.         break;
  34.         /****************************************/
  35.         case 1:
  36.         break;
  37.         /****************************************/
  38.         case 2:
  39.             a0 = 0.1 + rnd(0.2);
  40.         break;
  41.         /****************************************/
  42.         /** Radar Sweep                        **/
  43.         case 3:
  44.             a0 = 0.7 + rnd(1.1);
  45.         break;
  46.         /****************************************/
  47.         /** Flower Power                       **/
  48.         case 4:
  49.             a0 = 2.0 + (float)((ULONG)(0.99 * rnd(4.0)));
  50.             a1 = M_PI * (float)(2 - (ULONG)a0 % 2);
  51.             a2 = 0.2  + rnd(0.2);
  52.             a3 = 0.65 + rnd(0.22);
  53.         break;
  54.         /****************************************/
  55.         /** Spinit                             **/
  56.         case 5:
  57.             a0 = 0.25 + rnd(0.4);
  58.         break;
  59.         /****************************************/
  60.         /** Sine Waves                         **/
  61.         case 6:
  62.         break;
  63.         /****************************************/
  64.         /** Five                               **/
  65.         case 7:
  66.             a0 = cos(.3 + rnd(.6)) * 0.5;
  67.             a1 = sin(.5 + rnd(.4)) * 0.5;
  68.             a2 = cos(.1 + rnd(.8)) * 0.5;
  69.             a3 = sin(.2 + rnd(.7)) * 0.5;
  70.             a4 = cos(.6 + rnd(.3)) * 0.5;
  71.         break;
  72.         /****************************************/
  73.         /** Rotating Arcs                      **/
  74.         case 8:
  75.             a0 = 0.5 + rnd(0.2);
  76.             a1 = rnd(1.3) + 1.4;
  77.         break;
  78.         /****************************************/
  79.         /** Horizontal Sweep                   **/
  80.         case 9:
  81.         break;
  82.         /****************************************/
  83.         /** NTPU Squared                       **/
  84.         case 10:
  85.             a0 = 0.3 + rnd(0.4);
  86.             a1 = 0.4 * a0;
  87.         break;
  88.         /****************************************/
  89.         /** Particle Pulse                     **/
  90.         case 11:
  91.             a0 = rnd(3)+1;
  92.         break;
  93.         /****************************************/
  94.     }
  95.     wa0[BufNum] = a0;
  96.     wa1[BufNum] = a1;
  97.     wa2[BufNum] = a2;
  98.     wa3[BufNum] = a3;
  99.     wa4[BufNum] = a4;
  100. }
  101.  
  102. void CalcWave(UBYTE WaveNum, ULONG BufNum) {
  103.     float tf;
  104.     float a0,a1,a2,a3,a4;
  105.     float b0,b1,b2,b3,b4,b5,b6,b7,b8;
  106.  
  107.     a0 = wa0[BufNum];
  108.     a1 = wa1[BufNum];
  109.     a2 = wa2[BufNum];
  110.     a3 = wa3[BufNum];
  111.     a4 = wa4[BufNum];
  112.     b0 = 0;
  113.     b1 = 0;
  114.     b2 = 0;
  115.     b3 = 0;
  116.     b4 = 0;
  117.     b5 = 0;
  118.     b6 = 0;
  119.     b7 = 0;
  120.     b8 = 0;
  121.     tf=((float)TimeWave) / 10.0;
  122.     switch(WaveNum) {
  123.         /****************************************/
  124.         case 0:
  125.         break;
  126.         /****************************************/
  127.         case 1:
  128.             b0 = tf * 0.0003;
  129.         break;
  130.         /****************************************/
  131.         case 2:
  132.             b0 = cos(tf * 0.2);
  133.             b1 = sin(tf * 0.2);
  134.         break;
  135.         /****************************************/
  136.         /** Radar Sweep                        **/
  137.         case 3:
  138.             b0 = cos(tf * a0);
  139.             b1 = sin(tf * a0);
  140.         break;
  141.         /****************************************/
  142.         /** Flower Power                       **/
  143.         case 4:
  144.             b0 = tf;
  145.         break;
  146.         /****************************************/
  147.         /** Spinit                             **/
  148.         case 5:
  149.             b0 = cos(a0 * tf);
  150.             b1 = sin(a0 * tf);
  151.         break;
  152.         /****************************************/
  153.         /** Sine Waves                         **/
  154.         case 6:
  155.         break;
  156.         /****************************************/
  157.         /** Five                               **/
  158.         case 7:
  159.             b0 = -1.0 * tf;
  160.             b1 = .3 * tf;
  161.             b2 = -.8 * tf + 1.23213;
  162.             b3 = .3 * tf;
  163.             b4 = -1.3 * tf;
  164.             b5 = -1.1 * tf + 4.45245;
  165.             b6 = -.63 * tf + 2.13213;
  166.             b7 = .7 * cos(b1);
  167.             b8 = .7 * sin(b1);
  168.         break;
  169.         /****************************************/
  170.         /** Rotating Arcs                      **/
  171.         case 8:
  172.             b0 = 0.3 * tf;
  173.         break;
  174.         /****************************************/
  175.         /** Horizontal Sweep                   **/
  176.         case 9:
  177.             b0 = sin(0.5*tf);
  178.         break;
  179.         /****************************************/
  180.         /** NTPU Squared                       **/
  181.         case 10:
  182.             b0 = cos(tf * 0.18);
  183.             b1 = sin(tf * 0.18);
  184.         break;
  185.         /****************************************/
  186.         /** Particle Pulse                     **/
  187.         case 11:
  188.             b0 = tf * 0.0003;
  189.         break;
  190.         /****************************************/
  191.     }
  192.     wb0[BufNum] = b0;
  193.     wb1[BufNum] = b1;
  194.     wb2[BufNum] = b2;
  195.     wb3[BufNum] = b3;
  196.     wb4[BufNum] = b4;
  197.     wb5[BufNum] = b5;
  198.     wb6[BufNum] = b6;
  199.     wb7[BufNum] = b7;
  200.     wb8[BufNum] = b8;
  201. }
  202.  
  203. void DrawWave(LONG *WaveX, LONG *WaveY, ULONG Width, ULONG Height, UBYTE WaveNum, ULONG BufNum) {
  204.     LONG i,xs,ys,xd,yd;
  205.     LONG k;
  206.     LONG minx,maxx,miny,maxy;
  207.  
  208.     float scales,scaled,greater;
  209.     float xsf,ysf;
  210.     float xdf0,ydf0,xdf1,ydf1,xdf2,ydf2;
  211.     float wf,hf,tf;
  212.  
  213.     float a0, a1, a2, a3, a4;
  214.     float b0, b1, b2, b3, b4, b5, b6, b7, b8;
  215.     float c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10;
  216.  
  217.     a0 = wa0[BufNum];
  218.     a1 = wa1[BufNum];
  219.     a2 = wa2[BufNum];
  220.     a3 = wa3[BufNum];
  221.     a4 = wa4[BufNum];
  222.  
  223.     b0 = wb0[BufNum];
  224.     b1 = wb1[BufNum];
  225.     b2 = wb2[BufNum];
  226.     b3 = wb3[BufNum];
  227.     b4 = wb4[BufNum];
  228.     b5 = wb5[BufNum];
  229.     b6 = wb6[BufNum];
  230.     b7 = wb7[BufNum];
  231.     b8 = wb8[BufNum];
  232.  
  233.     wf=(float)Width;
  234.     hf=(float)Height;
  235.     tf=((float)TimeWave) / 10.0;
  236.  
  237.     minx = -(Width/2)  + 1;
  238.     maxx =  (Width/2)  - 1;
  239.     miny = -(Height/2) + 1;
  240.     maxy =  (Height/2) - 1;
  241.  
  242.     greater=1.0;
  243.     if(wf > greater) greater = wf;
  244.     if(hf > greater) greater = hf;
  245.  
  246.     scales = 1.0 / greater;
  247.     scaled = 1.0 / (greater/2.0);
  248.  
  249.     k=0;
  250.     for(xs=0; xs<(Width); xs++) {
  251.  
  252.         ys = (PluginSamples[k++] >> 10) + (PluginSamples[k++] >> 10);
  253.  
  254.         xsf = ((float)xs) * scales;
  255.         ysf = ((float)ys) / 256.0;
  256.  
  257.         switch(WaveNum) {
  258.             /****************************************/
  259.             case 0:
  260.                 xdf0 = 2*xsf-1;
  261.                 ydf0 = ysf * 0.75;
  262.                 xdf1 = xdf0;
  263.                 ydf1 = ydf0;
  264.             break;
  265.             /****************************************/
  266.             case 1:
  267.                 c0 = ysf * 0.2 + .2;
  268.                 c1 = xsf * 6.28318530 + b0;
  269.                 xdf0 = c0 * cos(c1);
  270.                 ydf0 = c0 * sin(c1);
  271.                 xdf1 = xdf0;
  272.                 ydf1 = ydf0;
  273.             break;
  274.             /****************************************/
  275.             case 2:
  276.                 c0 = ysf * 0.25 + .2;
  277.                 c1 = 2.1 * (xsf-0.5);
  278.                 xdf0 =  b0 * c1 + b1 * c0;
  279.                 ydf0 = -b0 * c0 + b1 * c1;
  280.                 xdf1 =  b0 * c1 - b1 * c0;
  281.                 ydf1 =  b0 * c0 + b1 * c1;
  282.             break;
  283.             /****************************************/
  284.             /** Radar Sweep                        **/
  285.             case 3:
  286.                 c0   = ysf * 0.4 * xsf;
  287.                 xdf0 = -b0 * xsf - b1 * c0;
  288.                 ydf0 =  b0 * c0  - b1 * xsf;
  289.                 xdf1 = xdf0;
  290.                 ydf1 = ydf0;
  291.             break;
  292.             /****************************************/
  293.             /** Flower Power                       **/
  294.             case 4:
  295.                 c0   = a1 * xsf;
  296.                 c1   = a3 * cos(a0*c0) + 0.18 * ysf;
  297.                 xdf0 = c1 * cos(c0+a2*b0);
  298.                 ydf0 = c1 * sin(c0+a2*b0);
  299.                 xdf1 = xdf0;
  300.                 ydf1 = ydf0;
  301.             break;
  302.             /****************************************/
  303.             /** Spinit                             **/
  304.             case 5:
  305.                 c0   = 2 * xsf - 1;
  306.                 c1   = ysf * 0.6 + c0;
  307.                 xdf0 = - b0 * c0 - b1 * c1;
  308.                 ydf0 =   b0 * c1 - b1 * c0;
  309.                 xdf1 = - b0 * c0 + b1 * c1;
  310.                 ydf1 =   b0 * c1 + b1 * c0;
  311.             break;
  312.             /****************************************/
  313.             /** Sine Waves                         **/
  314.             case 6:
  315.                 c0   = - sin(6.2831853 * xsf);
  316.                 c1   = 0.4 * ysf;
  317.                 xdf0 = 2.0 * xsf - 1 - c0 * c1;
  318.                 ydf0 = 0.7 * cos( 6.2831853 * xsf ) + sqrt( 1 - c0*c0 ) * c1;
  319.                 xdf1 = xdf0;
  320.                 ydf1 = -ydf0;
  321.             break;
  322.             /****************************************/
  323.             /** Five                               **/
  324.             case 7:
  325.                 c0   = b7 * ( xsf - .1 ) + a0;
  326.                 c1   = b8 * ( xsf - .1 ) + a0;
  327.                 c2   = .7 * ( xsf - .1 ) * sin( b3 ) + a1;
  328.                 c3   = .7 * ( xsf - .1 ) * cos( b3 ) + a1;
  329.                 c4   = b7 * ( xsf - .1 ) + a2;
  330.                 c5   = b8 * ( xsf - .1 ) + a2;
  331.                 c6   = b7 * ( xsf - .1 ) + a3;
  332.                 c7   = b8 * ( xsf - .1 ) + a3;
  333.                 c8   = b7 * ( xsf - .1 ) + a4;
  334.                 c9   = b8 * ( xsf - .1 ) + a4;
  335.                 c10  = .7 * ysf;
  336.  
  337.                 switch(xs%5) {
  338.                     case 0:
  339.                         xdf0 = c0 * cos(b0) - c1 * sin(b0);
  340.                         ydf0 = c1 * sin(b0) + c0 * cos(b0) * c10;
  341.                     break;
  342.                     case 1:
  343.                         xdf0 = -(c0 * sin(b2) - c1 * cos(b2));
  344.                         ydf0 = -(c1 * cos(b2) + c0 * sin(b2) * c10);
  345.                     break;
  346.                     case 2:
  347.                         xdf0 = -(c4 * sin(b4) - c5 * cos(b4));
  348.                         ydf0 = -(c5 * cos(b4) + c4 * sin(b4) * c10);
  349.                     break;
  350.                     case 3:
  351.                         xdf0 = c6 * cos(b5) - c7 * sin(b5);
  352.                         ydf0 = c7 * sin(b5) + c6 * cos(b5) * c10;
  353.                     break;
  354.                     case 4:
  355.                         xdf0 = -c8 * cos(b6) - c9 * sin(b6);
  356.                         ydf0 = -c9 * sin(b6) + c8 * cos(b6) * c10;
  357.                     break;
  358.                 }
  359.                 xdf1 = xdf0;
  360.                 ydf1 = ydf0;
  361.             break;
  362.             /****************************************/
  363.             /** Rotating Arcs                      **/
  364.             case 8:
  365.                 c0   = a0 + .025 * ysf;
  366.                 c1   = b0 + a1 * xsf;
  367.  
  368.                 xdf0 = c0 * cos(c1);
  369.                 ydf0 = c0 * sin(c1);
  370.                 xdf1 = c0 * cos(c1 + 3.14159);
  371.                 ydf1 = c0 * sin(c1 + 3.14159);
  372.             break;
  373.             /****************************************/
  374.             /** Horizontal Sweep                   **/
  375.             case 9:
  376.                 c0   = 2 * (xsf - 0.5);
  377.                 c1   = 0.7 * b0 + ysf * 0.25;
  378.  
  379.                 xdf0 =  c1;
  380.                 ydf0 =  c0;
  381.                 xdf1 = -c1;
  382.                 ydf1 =  c0;
  383.             break;
  384.             /****************************************/
  385.             /** NTPU Squared                       **/
  386.             case 10:
  387.                 c0   = a1 * ysf + a0;
  388.                 c1   = 2.0 * a0 * (xsf - 0.5);
  389.  
  390.                 switch(xs%2) {
  391.                     case 0:
  392.                         xdf0 =   b0 * c1 + b1 * c0;
  393.                         ydf0 = - b0 * c0 + b1 * c1;
  394.                         xdf1 =   b0 * c1 - b1 * c0;
  395.                         ydf1 =   b0 * c0 + b1 * c1;
  396.                     break;
  397.                     case 1:
  398.                         xdf0 = - b0 * c1 - b1 * c0;
  399.                         ydf0 = - b0 * c0 + b1 * c1;
  400.                         xdf1 = - b0 * c1 + b1 * c0;
  401.                         ydf1 =   b0 * c0 + b1 * c1;
  402.                     break;
  403.                 }
  404.             break;
  405.             /****************************************/
  406.             /** NTPU Squared                       **/
  407.             case 11:
  408.                 c0   = fabs(ysf) * 0.85 + 0.05;
  409.                 c1   = xsf * 43.766877 - b0;
  410.  
  411.                 switch(xs%2) {
  412.                     case 0:
  413.                         xdf0 = c0 * cos(c1);
  414.                         ydf0 = c0 * sin(c1);
  415.                         xdf1 = c0 * cos(c1)+scaled;
  416.                         ydf1 = c0 * sin(c1);
  417.                     break;
  418.                     case 1:
  419.                         xdf0 = c0 * cos(c1);
  420.                         ydf0 = c0 * sin(c1)+scaled;
  421.                         xdf1 = c0 * cos(c1)+scaled;
  422.                         ydf1 = c0 * sin(c1)+scaled;
  423.                     break;
  424.                 }
  425.             break;
  426.             /****************************************/
  427.         }
  428.  
  429.         xd = xdf0/scaled;
  430.         yd = ydf0/scaled;
  431.         /**
  432.         if(xd < minx) xd = minx;
  433.         if(xd > maxx) xd = maxx;
  434.         if(yd < miny) yd = miny;
  435.         if(yd > maxy) yd = maxy;
  436.         **/
  437.         WaveX[xs] = xd;
  438.         WaveY[xs] = yd;
  439.  
  440.         xd = xdf1/scaled;
  441.         yd = ydf1/scaled;
  442.         /**
  443.         if(xd < minx) xd = minx;
  444.         if(xd > maxx) xd = maxx;
  445.         if(yd < miny) yd = miny;
  446.         if(yd > maxy) yd = maxy;
  447.         **/
  448.         WaveX[xs+Width] = xd;
  449.         WaveY[xs+Width] = yd;
  450.     }
  451. }
  452.